/*
 * leerFAT.c
 *
 *  Created on: 06/10/2011
 *      Author: utn_so
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include "iniciarFat.h"
#include "estaticas.h"
#include "direccionamiento.h"
#include "archivos_abiertos.h"

// uint32_t *fat; //puntero a la Tabla de Asignación de Archivos
// struct bootSectorStruct *bootSector; //Puntero a una estructura que guarda información del Boot Sector

uint32_t leerBootSector()
{
	/*
	 * Se solicita el Bloque 0 para realizar la lectura del BootSector
	 */

	bootSector = (struct bootSectorStruct *) malloc (sizeof(struct bootSectorStruct));

	char *bloque;
	bloque = (char *) malloc (TAMANO_BLOQUE);

	bloque = SolicitarBloque(0, 0);


/* para PRUEBA*/

//	FILE *disk;
//	disk = fopen("/home/utn_so/Desarrollo/FUSEVOL2","r"); //abro el archivo que representa el volumen FAT32 de prueba, luego vamos a tener que leer un cluster. Pero para ir armando el BootSector, esto nos sirve.
//	fread(bloque,512,1,disk); //lee los primeros 512 bytes del disco y los guardo en el array

	/*para PRUEBAS */

	memcpy (&bootSector->bytesPorSector, bloque + 11, 2);
	memcpy (&bootSector->sectoresPorCluster, bloque + 13, 1);
	memcpy (&bootSector->sectorComienzoFat, bloque + 14, 2);
	memcpy (&bootSector->cantidadDeFat, bloque + 16, 1);
	memcpy (&bootSector->cantidadTotalDeSectores, bloque + 32, 4);
	memcpy (&bootSector->sectoresPorFat, bloque + 36, 4);
	memcpy (&bootSector->clusterRaiz, bloque + 44, 4);
	memcpy (&bootSector->sectorFSinfo, bloque + 48, 2);
	memcpy (&bootSector->ID_NumeroDeSerie, bloque + 67, 4);

	free(bloque);
	return 0;

}


uint32_t leerFat() /* es global y se le debe asignar*/
{

	/*
	 * Se realiza la lectura de la FAT Region y se guarda en un vector de enteros
	 */

	char *bloque;
//	bloque =(char *) malloc (TAMANO_BLOQUE);
	pthread_mutex_lock(&mutexFat);
	fat = (uint32_t *) malloc (bootSector->sectoresPorFat * bootSector->bytesPorSector);
	//lo casteo como char por que necesito (sectores por fat * bytePorSector de bytes)
	//si hago (uint32_t *) me multiplica por 4

	uint32_t i, comienzoBloque, cantidadBloquesCompletosEnFat, sobrante;

	comienzoBloque = bootSector->sectorComienzoFat / SECTORES_POR_BLOQUE;
	cantidadBloquesCompletosEnFat = bootSector->sectoresPorFat / SECTORES_POR_BLOQUE;
	sobrante = bootSector->sectoresPorFat % SECTORES_POR_BLOQUE;


	for (i = comienzoBloque; i < cantidadBloquesCompletosEnFat; i++)
	{
		bloque = SolicitarBloque(i, 0);
		memcpy (( (char *)fat + (TAMANO_BLOQUE * (i-comienzoBloque))), bloque, TAMANO_BLOQUE);
		free(bloque);
	}

	if (sobrante != 0)
	{

		i++;
		bloque = SolicitarBloque(i, 0);
		memcpy ((char *) (fat + (TAMANO_BLOQUE * (i-comienzoBloque))), bloque, (sobrante * bootSector->bytesPorSector));
		free(bloque);
	}
	pthread_mutex_unlock(&mutexFat);



	return 0;
}

void inicializarMutex(){
	pthread_mutexattr_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutex_init(&mutexFat,&attr);
	pthread_mutex_init(&mutexClustersLibres,&attr);
	pthread_mutex_init(&mutexArchivosAbiertos,&attr);

	pthread_mutexattr_destroy(&attr);

}
